home *** CD-ROM | disk | FTP | other *** search
/ Aminet 41 / Aminet 41 (2001)(Schatztruhe)[!][Feb 2001].iso / Aminet / comm / misc / MPackMUI.lha / MPackMUI / Source / MPack.C < prev    next >
Encoding:
C/C++ Source or Header  |  2000-07-27  |  21.4 KB  |  833 lines
  1. // --------------------------------------------------------------------------------------------------------------
  2. //
  3. //   MPackMUI V1.01 MPack Module
  4. //
  5. // --------------------------------------------------------------------------------------------------------------
  6.  
  7. #include "MPack.h"
  8.  
  9. // --------------------------------------------------------------------------------------------------------------
  10.  
  11. void Encode2File()
  12. {
  13.     BPTR tempfile;
  14.     char commandline[512], tempcommand[256];
  15.     LONG returncode, mimetype, *inputfile, *outputfile, *descfile, *subject, *state, *maxsize;
  16.     struct FileInfoBlock *fib;
  17.  
  18.     // Encode a file to a file
  19.  
  20.     // Send window to sleep
  21.  
  22.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  23.  
  24.     // Get the input file, output file and subject
  25.  
  26.     get(Gadgets[GID_INPUT_STRING_P1], MUIA_String_Contents, &inputfile);
  27.     get(Gadgets[GID_OUTPUT_STRING_P1], MUIA_String_Contents, &outputfile);
  28.     get(Gadgets[GID_SUBJECT_STRING_P1], MUIA_String_Contents, &subject);
  29.  
  30.     // Check if MPack is in C:
  31.  
  32.     if (!(tempfile = Lock("c:mpack", ACCESS_READ)))
  33.     {
  34.         DoEasyReq("Couldn't find MPack");
  35.  
  36.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  37.         return;
  38.     } /* if */
  39.  
  40.     UnLock(tempfile);
  41.  
  42.     // Check if we can open the input file
  43.  
  44.     if (!(tempfile = Lock((char *)inputfile, ACCESS_READ)))
  45.     {
  46.         DoEasyReq("Couldn't open input file");
  47.  
  48.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  49.         return;
  50.     } /* if */
  51.  
  52.     // Allocate FileInfoBlock (freed later)
  53.  
  54.     if (!(fib = AllocDosObjectTags(DOS_FIB,                                     TAG_DONE)))
  55.     {
  56.         DoEasyReq("Couldn't allocate FileInfoBlock");
  57.  
  58.         UnLock(tempfile);
  59.         CleanUp();
  60.     } /* if */
  61.  
  62.     Examine(tempfile, fib);
  63.  
  64.     if (fib->fib_DirEntryType > 0)
  65.     {
  66.         DoEasyReq("Couldn't open input file");
  67.  
  68.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  69.         FreeDosObject(DOS_FIB, fib);
  70.         UnLock(tempfile);
  71.         return;
  72.     } /* if */
  73.  
  74.     UnLock(tempfile);
  75.  
  76.     // Check if we can open the output file
  77.  
  78.     if (tempfile = Lock((char *)outputfile, ACCESS_READ))
  79.     {
  80.         Examine(tempfile, fib);
  81.  
  82.         if (fib->fib_DirEntryType > 0)
  83.         {
  84.             DoEasyReq("Couldn't open output file");
  85.  
  86.             set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  87.             FreeDosObject(DOS_FIB, fib);
  88.             UnLock(tempfile);
  89.             return;
  90.         } /* if */
  91.  
  92.         UnLock(tempfile);
  93.     } /* if */
  94.  
  95.     // Check if a description file is present
  96.  
  97.     get(Gadgets[GID_DESC_STRING_P1], MUIA_Disabled, &state);
  98.  
  99.     if (!(state))
  100.     {
  101.         // Check if we can open the description file
  102.  
  103.         get(Gadgets[GID_DESC_STRING_P1], MUIA_String_Contents, &descfile);
  104.  
  105.         if (!(tempfile = Lock((char *)descfile, ACCESS_READ)))
  106.         {
  107.             DoEasyReq("Couldn't open description file");
  108.  
  109.             set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  110.             FreeDosObject(DOS_FIB, fib);
  111.             return;
  112.         } /* if */
  113.  
  114.         Examine(tempfile, fib);
  115.  
  116.         if (fib->fib_DirEntryType > 0)
  117.         {
  118.             DoEasyReq("Couldn't open description file");
  119.  
  120.             set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  121.             FreeDosObject(DOS_FIB, fib);
  122.             UnLock(tempfile);
  123.             return;
  124.         } /* if */
  125.  
  126.         UnLock(tempfile);
  127.     } /* if */
  128.  
  129.     // Free the FileInfoBlock
  130.  
  131.     FreeDosObject(DOS_FIB, fib);
  132.  
  133.     // Now construct the command line
  134.  
  135.     sprintf(commandline, "mpack -o \"%s\" -s \"%s\" ", outputfile, subject);
  136.  
  137.     // If there is a description file, add it to the command line
  138.  
  139.     if (!(state))
  140.     {
  141.         sprintf(tempcommand, "-d \"%s\" ", descfile);
  142.         strcat(commandline, tempcommand);
  143.     } /* if */
  144.  
  145.     // If there is a maximum size, add it to the command line
  146.  
  147.     get(Gadgets[GID_MAX_STRING_P1], MUIA_Disabled, &state);
  148.  
  149.     if (!(state))
  150.     {
  151.         get(Gadgets[GID_MAX_STRING_P1], MUIA_String_Integer, &maxsize);
  152.  
  153.         sprintf(tempcommand, "-m %ld ", maxsize);
  154.         strcat(commandline, tempcommand);
  155.     } /* if */
  156.  
  157.     // Add the content type to the command line
  158.  
  159.     get(Gadgets[GID_TYPE_CYCLE_P1], MUIA_Cycle_Active, &mimetype);
  160.  
  161.     sprintf(tempcommand, "-c \"%s\" ", MIMETypes[mimetype]);
  162.     strcat(commandline, tempcommand);
  163.  
  164.     // Add the input file to the command line
  165.  
  166.     sprintf(tempcommand, "\"%s\"", inputfile);
  167.     strcat(commandline, tempcommand);
  168.  
  169.     // Set gauge to on
  170.  
  171.     set(Gadgets[GID_PROGRESS_GAUGE_P1], MUIA_Gauge_InfoText, "Encoding file");
  172.     set(Gadgets[GID_PROGRESS_GAUGE_P1], MUIA_Gauge_Current, 1);
  173.  
  174.     // And execute the whole commandline
  175.  
  176.     if ((returncode = SystemTags(commandline,                                   TAG_DONE)) == RETURN_ERROR)
  177.     {
  178.         DoEasyReq("Couldn't find MPack");
  179.     } /* if */
  180.  
  181.     // Set gauge to off
  182.  
  183.     set(Gadgets[GID_PROGRESS_GAUGE_P1], MUIA_Gauge_Current, 0);
  184.     set(Gadgets[GID_PROGRESS_GAUGE_P1], MUIA_Gauge_InfoText, "");
  185.  
  186.     // Wake up window
  187.  
  188.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  189. } /* Encode2File() */
  190.  
  191. // --------------------------------------------------------------------------------------------------------------
  192.  
  193. void Decode2File()
  194. {
  195.     BPTR tempfile;
  196.     char commandline[512], tempcommand[256], inputbase[256], testfilename[256], gaugetext[256];
  197.     LONG returncode, *inputfile, *outputdir, *state1, *state2;
  198.     struct FileInfoBlock *fib;
  199.     UBYTE numfiles, pos, loop;
  200.  
  201.     // Decode a file to a file
  202.  
  203.     // Send window to sleep
  204.  
  205.     set(Windows[WID_MAIN], MUIA_Window_Sleep, TRUE);
  206.  
  207.     // Get the input file and output directory
  208.  
  209.     get(Gadgets[GID_INPUT_STRING_P2], MUIA_String_Contents, &inputfile);
  210.     get(Gadgets[GID_OUTPUT_STRING_P2], MUIA_String_Contents, &outputdir);
  211.  
  212.     // Check if Munpack is in C:
  213.  
  214.     if (!(tempfile = Lock("c:munpack", ACCESS_READ)))
  215.     {
  216.         DoEasyReq("Couldn't find Munpack");
  217.  
  218.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  219.         return;
  220.     } /* if */
  221.  
  222.     UnLock(tempfile);
  223.  
  224.     // Check if we can open the input file
  225.  
  226.     if (!(tempfile = Lock((char *)inputfile, ACCESS_READ)))
  227.     {
  228.         DoEasyReq("Couldn't open input file");
  229.  
  230.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  231.         return;
  232.     } /* if */
  233.  
  234.     // Allocate FileInfoBlock (freed later)
  235.  
  236.     if (!(fib = AllocDosObjectTags(DOS_FIB,                                     TAG_DONE)))
  237.     {
  238.         DoEasyReq("Couldn't allocate FileInfoBlock");
  239.  
  240.         UnLock(tempfile);
  241.         CleanUp();
  242.     } /* if */
  243.  
  244.     Examine(tempfile, fib);
  245.  
  246.     if (fib->fib_DirEntryType > 0)
  247.     {
  248.         DoEasyReq("Couldn't open input file");
  249.  
  250.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  251.         FreeDosObject(DOS_FIB, fib);
  252.         UnLock(tempfile);
  253.         return;
  254.     } /* if */
  255.  
  256.     UnLock(tempfile);
  257.  
  258.     // Check if the output directory is OK
  259.  
  260.     if (!(tempfile = Lock((char *)outputdir, ACCESS_READ)))
  261.     {
  262.         DoEasyReq("Invalid output directory");
  263.  
  264.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  265.         FreeDosObject(DOS_FIB, fib);
  266.         return;
  267.     } /* if */
  268.  
  269.     Examine(tempfile, fib);
  270.  
  271.     if (fib->fib_DirEntryType < 0)
  272.     {
  273.         DoEasyReq("Invalid output directory");
  274.  
  275.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  276.         FreeDosObject(DOS_FIB, fib);
  277.         UnLock(tempfile);
  278.         return;
  279.     } /* if */
  280.  
  281.     UnLock(tempfile);
  282.  
  283.     // Check for Force and Unpack
  284.  
  285.     get(Gadgets[GID_FORCE_CHECK_P2], MUIA_Selected, &state1);
  286.     get(Gadgets[GID_UNPACK_CHECK_P2], MUIA_Selected, &state2);
  287.  
  288.     // Check how many files there are
  289.  
  290.     pos = strlen((char *)inputfile);
  291.  
  292.     while (pos != 0 && ((char *)inputfile)[pos] != '.')
  293.     {
  294.         pos--;
  295.     } /* while */
  296.  
  297.     if (pos == 0 || isdigit(((char *)inputfile)[pos + 1]) == 0)
  298.     {
  299.         // Only one file, so just decode it and exit
  300.  
  301.         // Set gauge to on
  302.  
  303.         set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_Current, 1);
  304.         set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_Max, 1);
  305.         set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_InfoText, "Decoding file 1 / 1");
  306.  
  307.         sprintf(commandline, "munpack >NIL: <NIL: -C \"%s\" -q ", outputdir);
  308.  
  309.         if (state1)
  310.         {
  311.             strcat(commandline, "-f ");
  312.         } /* if */
  313.  
  314.         if (state2)
  315.         {
  316.             strcat(commandline, "-t ");
  317.         } /* if */
  318.  
  319.         sprintf(tempcommand, "\"%s\"", inputfile);
  320.  
  321.         strcat(commandline, tempcommand);
  322.  
  323.         if ((returncode = SystemTags(commandline,                                   TAG_DONE)) == RETURN_ERROR)
  324.         {
  325.             DoEasyReq("Couldn't find Munpack");
  326.         } /* if */
  327.  
  328.         // Reset gauge to off
  329.  
  330.         set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_Current, 0);
  331.         set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_InfoText, "");
  332.  
  333.         // Wake up window
  334.  
  335.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  336.  
  337.         return;
  338.     } /* if */
  339.  
  340.     // Multi-part files found, find how many
  341.  
  342.     // Get base of name, e.g. for file Packed.01, base is Packed
  343.  
  344.     strncpy(inputbase, (char *)inputfile, pos);
  345.     inputbase[pos] = '\0';
  346.  
  347.     numfiles = 1;
  348.     loop = TRUE;
  349.  
  350.     while (loop == TRUE)
  351.     {
  352.         if (numfiles < 10)
  353.         {
  354.             sprintf(testfilename, "%s.0%ld", inputbase, numfiles);
  355.         } /* if */
  356.  
  357.         else
  358.         {
  359.             sprintf(testfilename, "%s.%ld", inputbase, numfiles);
  360.         } /* else */
  361.  
  362.         if (!(tempfile = Lock(testfilename, ACCESS_READ)))
  363.         {
  364.             loop = FALSE;
  365.         } /* if */
  366.  
  367.         else
  368.         {
  369.             UnLock(tempfile);
  370.             numfiles++;
  371.         } /* else */
  372.     } /* while */
  373.  
  374.     numfiles--;
  375.  
  376.     // Now we have a base name and the number of files. Let's decode them all
  377.  
  378.     // Set gauge to on
  379.  
  380.     set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_Max, numfiles);
  381.     sprintf(gaugetext, "Decoding file %%ld / %ld", numfiles);
  382.     set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_InfoText, gaugetext);
  383.  
  384.     for (loop = 1; loop < numfiles + 1; loop++)
  385.     {
  386.         set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_Current, loop);
  387.  
  388.         if (loop < 10)
  389.         {
  390.             sprintf(testfilename, "%s.0%ld", inputbase, loop);
  391.         } /* if */
  392.  
  393.         else
  394.         {
  395.             sprintf(testfilename, "%s.%ld", inputbase, loop);
  396.         } /* else */
  397.  
  398.         sprintf(commandline, "munpack >NIL: <NIL: -C \"%s\" -q ", (char *)outputdir);
  399.  
  400.         if (state1)
  401.         {
  402.             strcat(commandline, "-f ");
  403.         } /* if */
  404.  
  405.         if (state2)
  406.         {
  407.             strcat(commandline, "-t ");
  408.         } /* if */
  409.  
  410.         sprintf(tempcommand, "\"%s\"", testfilename);
  411.         strcat(commandline, tempcommand);
  412.  
  413.         if ((returncode = SystemTags(commandline,                                   TAG_DONE)) == RETURN_ERROR)
  414.         {
  415.             DoEasyReq("Couldn't find Munpack");
  416.         } /* if */
  417.     } /* for */
  418.  
  419.     // Reset gauge to off
  420.  
  421.     set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_InfoText, "");
  422.     set(Gadgets[GID_PROGRESS_GAUGE_P2], MUIA_Gauge_Current, 0);
  423.  
  424.     // Wake up window
  425.  
  426.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  427. } /* Decode2File() */
  428.  
  429. // --------------------------------------------------------------------------------------------------------------
  430.  
  431. void Encode2Mail()
  432. {
  433.     BPTR tempfile;
  434.     char commandline[512], tempcommand[256], sendmailprog[256], tempsendmailprog[256], message[256];
  435.     LONG returncode, mimetype, *inputfile, *address, *subject, *state, *descfile, *maxsize;
  436.     struct FileInfoBlock *fib;
  437.  
  438.     // Encode a file and send by E-Mail
  439.  
  440.     // Send window to sleep
  441.  
  442.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  443.  
  444.     // Get the input file, address(es) and subject
  445.  
  446.     get(Gadgets[GID_INPUT_STRING_P3], MUIA_String_Contents, &inputfile);
  447.     get(Gadgets[GID_ADDRESS_STRING_P3], MUIA_String_Contents, &address);
  448.     get(Gadgets[GID_SUBJECT_STRING_P3], MUIA_String_Contents, &subject);
  449.  
  450.     // Check if MPack is in C:
  451.  
  452.     if (!(tempfile = Lock("c:mpack", ACCESS_READ)))
  453.     {
  454.         DoEasyReq("Couldn't find MPack");
  455.  
  456.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  457.         return;
  458.     } /* if */
  459.  
  460.     UnLock(tempfile);
  461.  
  462.     // Attempt to locate file used to send mail (stored in variable SENDMAIL)
  463.  
  464.     if ((GetVar("SENDMAIL", sendmailprog, 256, NULL)) == -1)
  465.     {
  466.         strcpy(sendmailprog, "sendmail");
  467.     } /* if */
  468.  
  469.     sprintf(tempsendmailprog, "c:%s", sendmailprog);
  470.  
  471.     // Check if Sendmail is in C:
  472.  
  473.     if (!(tempfile = Lock(tempsendmailprog, ACCESS_READ)))
  474.     {
  475.         sprintf(message, "Couldn't find %s", sendmailprog);
  476.  
  477.         DoEasyReq(message);
  478.  
  479.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  480.         return;
  481.     } /* if */
  482.  
  483.     UnLock(tempfile);
  484.  
  485.     // Check if we can open the input file
  486.  
  487.     if (!(tempfile = Lock((char *)inputfile, ACCESS_READ)))
  488.     {
  489.         DoEasyReq("Couldn't open input file");
  490.  
  491.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  492.         return;
  493.     } /* if */
  494.  
  495.     // Allocate FileInfoBlock (freed later)
  496.  
  497.     if (!(fib = AllocDosObjectTags(DOS_FIB,                                     TAG_DONE)))
  498.     {
  499.         DoEasyReq("Couldn't allocate FileInfoBlock");
  500.  
  501.         UnLock(tempfile);
  502.         CleanUp();
  503.     } /* if */
  504.  
  505.     Examine(tempfile, fib);
  506.  
  507.     if (fib->fib_DirEntryType > 0)
  508.     {
  509.         DoEasyReq("Couldn't open input file");
  510.  
  511.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  512.         FreeDosObject(DOS_FIB, fib);
  513.         UnLock(tempfile);
  514.         return;
  515.     } /* if */
  516.  
  517.     UnLock(tempfile);
  518.  
  519.     // Check we have an address
  520.  
  521.     if (((char *)address)[0] == '\0')
  522.     {
  523.         DoEasyReq("No address(es) specified");
  524.  
  525.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  526.         FreeDosObject(DOS_FIB, fib);
  527.         return;
  528.     } /* if */
  529.  
  530.     // Check if a description file is present
  531.  
  532.     get(Gadgets[GID_DESC_STRING_P3], MUIA_Disabled, &state);
  533.  
  534.     if (!(state))
  535.     {
  536.         // Check if we can open the description file
  537.  
  538.         get(Gadgets[GID_DESC_STRING_P3], MUIA_String_Contents, &descfile);
  539.  
  540.         if (!(tempfile = Lock((char *)descfile, ACCESS_READ)))
  541.         {
  542.             DoEasyReq("Couldn't open description file");
  543.  
  544.             set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  545.             FreeDosObject(DOS_FIB, fib);
  546.             return;
  547.         } /* if */
  548.  
  549.         Examine(tempfile, fib);
  550.  
  551.         if (fib->fib_DirEntryType > 0)
  552.         {
  553.             DoEasyReq("Couldn't open description file");
  554.  
  555.             set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  556.             FreeDosObject(DOS_FIB, fib);
  557.             UnLock(tempfile);
  558.             return;
  559.         } /* if */
  560.  
  561.         UnLock(tempfile);
  562.     } /* if */
  563.  
  564.     // Free the FileInfoBlock
  565.  
  566.     FreeDosObject(DOS_FIB, fib);
  567.  
  568.     // Now construct the command line
  569.  
  570.     sprintf(commandline, "mpack -s \"%s\" ", subject);
  571.  
  572.     // If there is a description file, add it to the command line
  573.  
  574.     if (!(state))
  575.     {
  576.         sprintf(tempcommand, "-d \"%s\" ", descfile);
  577.         strcat(commandline, tempcommand);
  578.     } /* if */
  579.  
  580.     // If there is a maximum size, add it to the command line
  581.  
  582.     get(Gadgets[GID_MAX_STRING_P3], MUIA_Disabled, &state);
  583.  
  584.     if (!(state))
  585.     {
  586.         get(Gadgets[GID_MAX_STRING_P3], MUIA_String_Integer, &maxsize);
  587.  
  588.         sprintf(tempcommand, "-m %ld ", maxsize);
  589.         strcat(commandline, tempcommand);
  590.     } /* if */
  591.  
  592.     // Add the content type to the command line
  593.  
  594.     get(Gadgets[GID_TYPE_CYCLE_P3], MUIA_Cycle_Active, &mimetype);
  595.  
  596.     sprintf(tempcommand, "-c \"%s\" ", MIMETypes[mimetype]);
  597.     strcat(commandline, tempcommand);
  598.  
  599.     // Add the input file and the address to the command line
  600.  
  601.     sprintf(tempcommand, "\"%s\" ", inputfile);
  602.     strcat(commandline, tempcommand);
  603.     strcat(commandline, (char *)address);
  604.  
  605.     // Set gauge to on
  606.  
  607.     set(Gadgets[GID_PROGRESS_GAUGE_P3], MUIA_Gauge_InfoText, "Encoding file");
  608.     set(Gadgets[GID_PROGRESS_GAUGE_P3], MUIA_Gauge_Current, 1);
  609.  
  610.     // And execute the whole commandline
  611.  
  612.     if ((returncode = SystemTags(commandline,                                   TAG_DONE)) == RETURN_ERROR)
  613.     {
  614.         DoEasyReq("Couldn't find MPack");
  615.     } /* if */
  616.  
  617.     // Set gauge to off
  618.  
  619.     set(Gadgets[GID_PROGRESS_GAUGE_P3], MUIA_Gauge_Current, 0);
  620.     set(Gadgets[GID_PROGRESS_GAUGE_P3], MUIA_Gauge_InfoText, "");
  621.  
  622.     // Wake up window
  623.  
  624.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  625.  
  626.     return;
  627. } /* Encode2Mail() */
  628.  
  629. // --------------------------------------------------------------------------------------------------------------
  630.  
  631. void Encode2NG()
  632. {
  633.     BPTR tempfile;
  634.     char commandline[512], tempcommand[256], postnewsprog[256], temppostnewsprog[256], message[256];
  635.     LONG returncode, mimetype, *inputfile, *newsgroup, *subject, *state, *descfile, *maxsize;
  636.     struct FileInfoBlock *fib;
  637.  
  638.     // Encode a file and post to a newsgroup
  639.  
  640.     // Send window to sleep
  641.  
  642.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  643.  
  644.     // Get the input file, newsgroup(s) and subject
  645.  
  646.     get(Gadgets[GID_INPUT_STRING_P4], MUIA_String_Contents, &inputfile);
  647.     get(Gadgets[GID_NEWSGROUP_STRING_P4], MUIA_String_Contents, &newsgroup);
  648.     get(Gadgets[GID_SUBJECT_STRING_P4], MUIA_String_Contents, &subject);
  649.  
  650.     // Check if MPack is in C:
  651.  
  652.     if (!(tempfile = Lock("c:mpack", ACCESS_READ)))
  653.     {
  654.         DoEasyReq("Couldn't find MPack");
  655.  
  656.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  657.         return;
  658.     } /* if */
  659.  
  660.     UnLock(tempfile);
  661.  
  662.     // Attempt to locate file used to post news (stored in variable POSTNEWS)
  663.  
  664.     if ((GetVar("POSTNEWS", postnewsprog, 256, NULL)) == -1)
  665.     {
  666.         strcpy(postnewsprog, "postnews");
  667.     } /* if */
  668.  
  669.     sprintf(temppostnewsprog, "c:%s", postnewsprog);
  670.  
  671.     // Check if Sendmail is in C:
  672.  
  673.     if (!(tempfile = Lock(temppostnewsprog, ACCESS_READ)))
  674.     {
  675.         sprintf(message, "Couldn't find %s", postnewsprog);
  676.  
  677.         DoEasyReq(message);
  678.  
  679.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  680.         return;
  681.     } /* if */
  682.  
  683.     UnLock(tempfile);
  684.  
  685.     // Check if we can open the input file
  686.  
  687.     if (!(tempfile = Lock((char *)inputfile, ACCESS_READ)))
  688.     {
  689.         DoEasyReq("Couldn't open input file");
  690.  
  691.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  692.         return;
  693.     } /* if */
  694.  
  695.     // Allocate FileInfoBlock (freed later)
  696.  
  697.     if (!(fib = AllocDosObjectTags(DOS_FIB,                                     TAG_DONE)))
  698.     {
  699.         DoEasyReq("Couldn't allocate FileInfoBlock");
  700.  
  701.         UnLock(tempfile);
  702.         CleanUp();
  703.     } /* if */
  704.  
  705.     Examine(tempfile, fib);
  706.  
  707.     if (fib->fib_DirEntryType > 0)
  708.     {
  709.         DoEasyReq("Couldn't open input file");
  710.  
  711.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  712.         FreeDosObject(DOS_FIB, fib);
  713.         UnLock(tempfile);
  714.         return;
  715.     } /* if */
  716.  
  717.     UnLock(tempfile);
  718.  
  719.     // Check we have an address
  720.  
  721.     if (((char *)newsgroup)[0] == '\0')
  722.     {
  723.         DoEasyReq("No newsgroup(s) specified");
  724.  
  725.         set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  726.         FreeDosObject(DOS_FIB, fib);
  727.         return;
  728.     } /* if */
  729.  
  730.     // Check if a description file is present
  731.  
  732.     get(Gadgets[GID_DESC_STRING_P4], MUIA_Disabled, &state);
  733.  
  734.     if (!(state))
  735.     {
  736.         // Check if we can open the description file
  737.  
  738.         get(Gadgets[GID_DESC_STRING_P4], MUIA_String_Contents, &descfile);
  739.  
  740.         if (!(tempfile = Lock((char *)descfile, ACCESS_READ)))
  741.         {
  742.             DoEasyReq("Couldn't open description file");
  743.  
  744.             set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  745.             FreeDosObject(DOS_FIB, fib);
  746.             return;
  747.         } /* if */
  748.  
  749.         Examine(tempfile, fib);
  750.  
  751.         if (fib->fib_DirEntryType > 0)
  752.         {
  753.             DoEasyReq("Couldn't open description file");
  754.  
  755.             set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  756.             FreeDosObject(DOS_FIB, fib);
  757.             UnLock(tempfile);
  758.             return;
  759.         } /* if */
  760.  
  761.         UnLock(tempfile);
  762.     } /* if */
  763.  
  764.     // Free the FileInfoBlock
  765.  
  766.     FreeDosObject(DOS_FIB, fib);
  767.  
  768.     // Now construct the command line
  769.  
  770.     sprintf(commandline, "mpack -s \"%s\" ", subject);
  771.  
  772.     // If there is a description file, add it to the command line
  773.  
  774.     if (!(state))
  775.     {
  776.         sprintf(tempcommand, "-d \"%s\" ", descfile);
  777.         strcat(commandline, tempcommand);
  778.     } /* if */
  779.  
  780.     // If there is a maximum size, add it to the command line
  781.  
  782.     get(Gadgets[GID_MAX_STRING_P4], MUIA_Disabled, &state);
  783.  
  784.     if (!(state))
  785.     {
  786.         get(Gadgets[GID_MAX_STRING_P4], MUIA_String_Integer, &maxsize);
  787.  
  788.         sprintf(tempcommand, "-m %ld ", maxsize);
  789.         strcat(commandline, tempcommand);
  790.     } /* if */
  791.  
  792.     // Add the content type to the command line
  793.  
  794.     get(Gadgets[GID_TYPE_CYCLE_P4], MUIA_Cycle_Active, &mimetype);
  795.  
  796.     sprintf(tempcommand, "-c \"%s\" ", MIMETypes[mimetype]);
  797.     strcat(commandline, tempcommand);
  798.  
  799.     // Add the input file and the address to the command line
  800.  
  801.     sprintf(tempcommand, "\"%s\" ", inputfile);
  802.     strcat(commandline, tempcommand);
  803.     sprintf(tempcommand, "-n %s", newsgroup);
  804.     strcat(commandline, tempcommand);
  805.  
  806.     // Set gauge to on
  807.  
  808.     set(Gadgets[GID_PROGRESS_GAUGE_P4], MUIA_Gauge_InfoText, "Encoding file");
  809.     set(Gadgets[GID_PROGRESS_GAUGE_P4], MUIA_Gauge_Current, 1);
  810.  
  811.     // And execute the whole commandline
  812.  
  813.     if ((returncode = SystemTags(commandline,                                   TAG_DONE)) == RETURN_ERROR)
  814.     {
  815.         DoEasyReq("Couldn't find MPack");
  816.     } /* if */
  817.  
  818.     // Set gauge to off
  819.  
  820.     set(Gadgets[GID_PROGRESS_GAUGE_P4], MUIA_Gauge_Current, 0);
  821.     set(Gadgets[GID_PROGRESS_GAUGE_P4], MUIA_Gauge_InfoText, "");
  822.  
  823.     // Wake up window
  824.  
  825.     set(Windows[WID_MAIN], MUIA_Window_Sleep, FALSE);
  826.  
  827.     return;
  828. } /* Encode2NG() */
  829.  
  830. // --------------------------------------------------------------------------------------------------------------
  831.  
  832. // End Of Text
  833.